home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Mediterranean / Mediterranean Small.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  51.2 KB  |  1,617 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Mediterranean Small.rmv
  4. //
  5. //
  6. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  7. // PROPRIETARY and CONFIDENTIAL.
  8. //
  9. // $Author: Scott Marison $
  10. // $Date: 9/14/01 10:07a $
  11. // $Revision: 10 $
  12. // 
  13. //  Revision: 8
  14. //        Adjusted Angle between team members 
  15. //  Revision: 9 
  16. //        Pushed players and outer neutrals toward the map edge
  17. //        increased land, trees, decreased outer neutrals and flat land 
  18. //        Assumes Initial Step = 64 in Mediterranean.rmv
  19. //  Revision: 15 Revised for miniaturization 
  20. //  Revision: 16 Elevation 
  21. //  Revision: 17 Revised # of resources 3 by 3
  22. //  Revision: 18 8+ player adjustment and enhanced resource placement 
  23. //  Revision: 19 General Adjustments for new map sizes
  24. //  Revision: 20 Reduced congestion 
  25. //  Revision: 23 Reduced Resources
  26. //  Revision: 24 Added Chance of steep cliffs 
  27. //  Revision: 26 Evened-out resource distribution 
  28. //  Revision: 27 Reduced Max angle between team members
  29. //  Revision: 28 Moved resources 2 tiles further from Capitol
  30. //  Revision: 30 Added 1 forage site
  31. //
  32. //////////////////////////////////////////////////////////////////////
  33.  
  34. #if            NOTDEFINED(MEDITERRANEAN_SMALL_RMV)
  35. #define        (MEDITERRANEAN_SMALL_RMV,1)
  36.  
  37. //////////////////////////////////////////////////////////////////////
  38. // Definitions we are required to define for Mediterranean maps
  39. //////////////////////////////////////////////////////////////////////
  40.  
  41. ResourcePlacementLimit (Gold,     8,    11)
  42. ResourcePlacementLimit (Steel,     8,     11)
  43. ResourcePlacementLimit (Stone,     8,     11)
  44. ResourcePlacementLimit (Berry,     7,     10)
  45. ResourcePlacementLimit (Fish,     1,    50)
  46. ResourcePlacementLimit (Tree,     3,     6)
  47. ResourcePlacementLimit (Animal,     7,     15)
  48.  
  49. #if Is2Players
  50. //////////////////////////////////////////////////////////////////////
  51. // 2 PLAYERS...
  52. //////////////////////////////////////////////////////////////////////
  53.  
  54. //////////////////////////////////////////////////////////////////////
  55. // terrain definitions
  56. #define        (kMinIntElevation,                -8)
  57.  
  58. #if        PERCENT(80)
  59.   #define        (kMaxIntElevation,            8)
  60. #else
  61.   #define        (kMaxIntElevation,            14)
  62. #endif 
  63.  
  64. #define        (kElevationScale,                    1)
  65. #define        (kPercentLand,                    Between(.7, .7))
  66. #define        (kWaterBorder,                    0)
  67. #define        (kHeightMapChaos,                    Between(4, 6))
  68.                                             
  69. #define        (kMinimumStartPositionToMapEdge        2)
  70. #define        (kOuterPushFromMapCenter            24)
  71. #define        (kInnerPushFromMapCenter             24)
  72.  
  73. #define        (kConvergentSampleSize,            32) 
  74. #define        (kConvergentThreshold,            1)
  75. //Leave this at 32,1 because this makes the ocean more circular
  76.  
  77. //////////////////////////////////////////////////////////////////////
  78. // player definitions
  79. #define        (kMaxAngleBetweenTeamMembers,        76.0)
  80. #define        (kPlayerInnerRadius,            0.6)
  81. #define        (kPlayerOuterRadius,            0.99)
  82. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  83. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  84. #define        (kPlayerLandChaos,            0.8)
  85. #define        (kPlayerLandClumps,            1)
  86. #define        (kPlayerFlatChaos,            0.8)
  87. #define        (kPlayerFlatClumps,            1)
  88. #define        (kPlayerTreePercentage,            0.15)
  89.  
  90.  
  91. //////////////////////////////////////////////////////////////////////
  92. // inner neutral definitions
  93. #define        (kNeutralInnerRadius,            0.45)
  94. #define        (kNeutralOuterRadius,            0.45)
  95. #define        (kNeutralOptimalFactor,            0.7)
  96. #define        (kNumInnerNeutrals,            Between(0, 0))
  97. #define        (kInnerNeutralPercentLand,        0.12)
  98. #define        (kInnerNeutralPercentFlat,        0.9)
  99. #define        (kInnerNeutralTreePercentage,      0.16)
  100. #define        (kInnerNeutralLandChaos,        0.9)
  101. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  102. #define        (kInnerNeutralFlatChaos,        0.8)
  103. #define        (kInnerNeutralFlatClumps,        1)
  104.  
  105.  
  106. //////////////////////////////////////////////////////////////////////
  107. // outer neutral definitions
  108. #define        (kNumOuterNeutrals,            20)
  109. #define        (kOuterNeutralPercentLand,        0.84)
  110. #define        (kOuterNeutralPercentFlat,        0.95)
  111. #define        (kOuterNeutralTreePercentage,      0.12)
  112. #define        (kOuterNeutralLandChaos,        0.8)
  113. #define        (kOuterNeutralLandClumps,        1)
  114. #define        (kOuterNeutralFlatChaos,        0.8)
  115. #define        (kOuterNeutralFlatClumps,        1)
  116.  
  117.  
  118. //////////////////////////////////////////////////////////////////////
  119. // resource definitions
  120. #define        (kMaxResourceElevation,            3)
  121. #define        (kResourceToEdgeDistance,        2)
  122. #define        (kResourceToWaterDistance,        2)
  123.  
  124. #define        (kAnimalPerPlayer,            0)
  125. #define        (kAnimalPerNeutral,            0)
  126.  
  127. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  128.   #define  (kBerryPerPlayer,    1) 
  129.   #define  (kBerryPerNeutral,      4)
  130. #else
  131.   #define  (kBerryPerPlayer,    1)
  132.   #define  (kBerryPerNeutral,      0)
  133. #endif 
  134.  
  135. #define        (kFishPerPlayer,                0)
  136. #define        (kFishPerNeutral,                25)
  137.  
  138. #define        (kGoldPerPlayer,                1)
  139. #define        (kGoldPerNeutral,                6)
  140.  
  141. #define        (kOilPerPlayer,                0)
  142. #define        (kOilPerNeutral,                0)
  143.  
  144. #define        (kSteelPerPlayer,                1)
  145. #define        (kSteelPerNeutral,            6)
  146.  
  147. #define        (kStonePerPlayer,                1)
  148. #define        (kStonePerNeutral,            2)
  149.  
  150. #define        (kTreePerPlayer,                1)
  151. #define        (kTreePerNeutral,                0)
  152.  
  153.  
  154. //////////////////////////////////////////////////////////////////////
  155. // forest definitions
  156. #define        (kForestFreeRadius,                9.0)
  157. #define        (kForestsPerPlayer,                1)
  158. #define        (kForestChaosLevel,                .1)
  159. #define        (kMaxClumpsPerForest,                    2)
  160.  
  161.  
  162. #elif Is3Players
  163. //////////////////////////////////////////////////////////////////////
  164. // 3 PLAYERS...
  165. //////////////////////////////////////////////////////////////////////
  166.  
  167. //////////////////////////////////////////////////////////////////////
  168. // terrain definitions
  169. #define        (kMinIntElevation,            -8)
  170.  
  171. #if        PERCENT(80)
  172.   #define        (kMaxIntElevation,            8)
  173. #else
  174.   #define        (kMaxIntElevation,            14)
  175. #endif 
  176.  
  177. #define        (kElevationScale,                0.99)
  178. #define        (kPercentLand,                Between(.7, .7))
  179. #define        (kWaterBorder,                0)
  180. #define        (kHeightMapChaos,                Between(4, 6))
  181.  
  182. #define        (kMinimumStartPositionToMapEdge    2)
  183. #define        (kOuterPushFromMapCenter        30)
  184. #define        (kInnerPushFromMapCenter         30)    
  185.  
  186. #define        (kConvergentSampleSize,            4) 
  187. #define        (kConvergentThreshold,            10)
  188.  
  189. //////////////////////////////////////////////////////////////////////
  190. // player definitions
  191. #define        (kMaxAngleBetweenTeamMembers,        76.0)
  192. #define        (kPlayerInnerRadius,            0.6)
  193. #define        (kPlayerOuterRadius,            0.99)
  194. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  195. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  196. #define        (kPlayerLandChaos,            0.8)
  197. #define        (kPlayerLandClumps,            1)
  198. #define        (kPlayerFlatChaos,            0.8)
  199. #define        (kPlayerFlatClumps,            1)
  200. #define        (kPlayerTreePercentage,            0.13)
  201.  
  202. //////////////////////////////////////////////////////////////////////
  203. // inner neutral definitions
  204. #define        (kNeutralInnerRadius,            0.4)
  205. #define        (kNeutralOuterRadius,            0.4)
  206. #define        (kNeutralOptimalFactor,            0.7)
  207. #define        (kNumInnerNeutrals,            Between(0, 0))
  208. #define        (kInnerNeutralPercentLand,        0.12)
  209. #define        (kInnerNeutralPercentFlat,        0.9)
  210. #define        (kInnerNeutralTreePercentage,          0.16)
  211. #define        (kInnerNeutralLandChaos,        0.9)
  212. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  213. #define        (kInnerNeutralFlatChaos,        0.8)
  214. #define        (kInnerNeutralFlatClumps,        1)
  215.  
  216.  
  217. //////////////////////////////////////////////////////////////////////
  218. // outer neutral definitions
  219. #define        (kNumOuterNeutrals,            17)
  220. #define        (kOuterNeutralPercentLand,        0.75)
  221. #define        (kOuterNeutralPercentFlat,        0.95)
  222. #define        (kOuterNeutralTreePercentage,          0.12)
  223. #define        (kOuterNeutralLandChaos,        0.8)
  224. #define        (kOuterNeutralLandClumps,        1)
  225. #define        (kOuterNeutralFlatChaos,        0.8)
  226. #define        (kOuterNeutralFlatClumps,        1)
  227.  
  228.  
  229. //////////////////////////////////////////////////////////////////////
  230. // resource definitions
  231. #define        (kMaxResourceElevation,            3)
  232. #define        (kResourceToEdgeDistance,        2)
  233. #define        (kResourceToWaterDistance,        2)
  234.  
  235. #define        (kAnimalPerPlayer,            0)
  236. #define        (kAnimalPerNeutral,            0)
  237.  
  238. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  239.   #define  (kBerryPerPlayer,    1) 
  240.   #define  (kBerryPerNeutral,      6)
  241. #else
  242.   #define  (kBerryPerPlayer,    1)
  243.   #define  (kBerryPerNeutral,      0)
  244. #endif 
  245.  
  246. #define        (kFishPerPlayer,                0)
  247. #define        (kFishPerNeutral,                25)
  248.  
  249. #define        (kGoldPerPlayer,                1)
  250. #define        (kGoldPerNeutral,                8)
  251.  
  252. #define        (kOilPerPlayer,                0)
  253. #define        (kOilPerNeutral,                0)
  254.  
  255. #define        (kSteelPerPlayer,                1)
  256. #define        (kSteelPerNeutral,            8)
  257.  
  258. #define        (kStonePerPlayer,                1)
  259. #define        (kStonePerNeutral,            3)
  260.  
  261. #define        (kTreePerPlayer,                1)
  262. #define        (kTreePerNeutral,                0)
  263.  
  264.  
  265. //////////////////////////////////////////////////////////////////////
  266. // forest definitions
  267. #define        (kForestFreeRadius,            8.0)
  268. #define        (kForestsPerPlayer,            1)
  269. #define        (kForestChaosLevel,            .1)
  270. #define        (kMaxClumpsPerForest,              2)
  271.  
  272.  
  273. #elif Is4Players
  274. //////////////////////////////////////////////////////////////////////
  275. // 4 PLAYERS...
  276. //////////////////////////////////////////////////////////////////////
  277.  
  278. //////////////////////////////////////////////////////////////////////
  279. // terrain definitions
  280. #define        (kMinIntElevation,            -8)
  281.  
  282. #if        PERCENT(80)
  283.   #define        (kMaxIntElevation,            8)
  284. #else
  285.   #define        (kMaxIntElevation,            14)
  286. #endif 
  287.  
  288. #define        (kElevationScale,                0.99)
  289. #define        (kPercentLand,                Between(.7, .7))
  290. #define        (kWaterBorder,                0)
  291. #define        (kHeightMapChaos,                Between(4, 6))
  292.  
  293. #define        (kMinimumStartPositionToMapEdge    2)
  294. #define        (kOuterPushFromMapCenter        24)
  295. #define        (kInnerPushFromMapCenter         24)    
  296.  
  297. #define        (kConvergentSampleSize,            5) 
  298. #define        (kConvergentThreshold,            8)
  299.  
  300.  
  301. //////////////////////////////////////////////////////////////////////
  302. // player definitions
  303. #define        (kMaxAngleBetweenTeamMembers,        66.0)
  304. #define        (kPlayerInnerRadius,            0.6)
  305. #define        (kPlayerOuterRadius,            0.99)
  306. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  307. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  308. #define        (kPlayerLandChaos,            0.8)
  309. #define        (kPlayerLandClumps,            1)
  310. #define        (kPlayerFlatChaos,            0.8)
  311. #define        (kPlayerFlatClumps,            1)
  312. #define        (kPlayerTreePercentage,            0.12)
  313.  
  314.  
  315. //////////////////////////////////////////////////////////////////////
  316. // inner neutral definitions
  317. #define        (kNeutralInnerRadius,            0.75)
  318. #define        (kNeutralOuterRadius,            0.75)
  319. #define        (kNeutralOptimalFactor,            0.7)
  320. #define        (kNumInnerNeutrals,            Between(0, 0))
  321. #define        (kInnerNeutralPercentLand,        0.16)
  322. #define        (kInnerNeutralPercentFlat,        0.9)
  323. #define        (kInnerNeutralTreePercentage,          0.17)
  324. #define        (kInnerNeutralLandChaos,        0.9)
  325. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  326. #define        (kInnerNeutralFlatChaos,        0.8)
  327. #define        (kInnerNeutralFlatClumps,        1)
  328.  
  329.  
  330. //////////////////////////////////////////////////////////////////////
  331. // outer neutral definitions
  332. #define        (kNumOuterNeutrals,            16)
  333. #define        (kOuterNeutralPercentLand,        0.75)
  334. #define        (kOuterNeutralPercentFlat,        0.95)
  335. #define        (kOuterNeutralTreePercentage,          0.12)
  336. #define        (kOuterNeutralLandChaos,        0.8)
  337. #define        (kOuterNeutralLandClumps,        1)
  338. #define        (kOuterNeutralFlatChaos,        0.8)
  339. #define        (kOuterNeutralFlatClumps,        1)
  340.  
  341.  
  342. //////////////////////////////////////////////////////////////////////
  343. // resource definitions
  344. #define        (kMaxResourceElevation,            3)
  345. #define        (kResourceToEdgeDistance,        1)
  346. #define        (kResourceToWaterDistance,        2)
  347.  
  348. #define        (kAnimalPerPlayer,            0)
  349. #define        (kAnimalPerNeutral,            0)
  350.  
  351. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  352.   #define  (kBerryPerPlayer,    1) 
  353.   #define  (kBerryPerNeutral,      5)
  354. #else
  355.   #define  (kBerryPerPlayer,    1)
  356.   #define  (kBerryPerNeutral,      0)
  357. #endif 
  358.  
  359. #define        (kFishPerPlayer,                0)
  360. #define        (kFishPerNeutral,                25)
  361.  
  362. #define        (kGoldPerPlayer,                1)
  363. #define        (kGoldPerNeutral,                9)
  364.  
  365. #define        (kOilPerPlayer,                0)
  366. #define        (kOilPerNeutral,                0)
  367.  
  368. #define        (kSteelPerPlayer,                1)
  369. #define        (kSteelPerNeutral,            9)
  370.  
  371. #define        (kStonePerPlayer,                1)
  372. #define        (kStonePerNeutral,            4)
  373.  
  374. #define        (kTreePerPlayer,                1)
  375. #define        (kTreePerNeutral,                0)
  376.  
  377.  
  378. //////////////////////////////////////////////////////////////////////
  379. // forest definitions
  380. #define        (kForestFreeRadius,            7.0)
  381. #define        (kForestsPerPlayer,            1)
  382. #define        (kForestChaosLevel,            .1)
  383. #define        (kMaxClumpsPerForest,              2)
  384.  
  385.  
  386. #elif Is5Players
  387. //////////////////////////////////////////////////////////////////////
  388. // 5 PLAYERS...
  389. //////////////////////////////////////////////////////////////////////
  390.  
  391. //////////////////////////////////////////////////////////////////////
  392. // terrain definitions
  393. #define        (kMinIntElevation,            -8)
  394.  
  395. #if        PERCENT(80)
  396.   #define        (kMaxIntElevation,            8)
  397. #else
  398.   #define        (kMaxIntElevation,            14)
  399. #endif 
  400.  
  401. #define        (kElevationScale,                0.99)
  402. #define        (kPercentLand,                Between(.7, .7))
  403. #define        (kWaterBorder,                0)
  404. #define        (kHeightMapChaos,                Between(3, 6))
  405.  
  406. #define        (kMinimumStartPositionToMapEdge    2)
  407. #define        (kOuterPushFromMapCenter        30)
  408. #define        (kInnerPushFromMapCenter         30)    
  409.  
  410. #define        (kConvergentSampleSize,            32) 
  411. #define        (kConvergentThreshold,            1)
  412.  
  413. //////////////////////////////////////////////////////////////////////
  414. // player definitions
  415. #define        (kMaxAngleBetweenTeamMembers,        66.0)
  416. #define        (kPlayerInnerRadius,            0.6)
  417. #define        (kPlayerOuterRadius,            0.99)
  418. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  419. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  420. #define        (kPlayerLandChaos,            0.8)
  421. #define        (kPlayerLandClumps,            1)
  422. #define        (kPlayerFlatChaos,            0.8)
  423. #define        (kPlayerFlatClumps,            1)
  424. #define        (kPlayerTreePercentage,            0.14)
  425.  
  426.  
  427. //////////////////////////////////////////////////////////////////////
  428. // inner neutral definitions
  429. #define        (kNeutralInnerRadius,            0.45)
  430. #define        (kNeutralOuterRadius,            0.45)
  431. #define        (kNeutralOptimalFactor,            0.7)
  432. #define        (kNumInnerNeutrals,            Between(0, 0))
  433. #define        (kInnerNeutralPercentLand,        0.11)
  434. #define        (kInnerNeutralPercentFlat,        0.9)
  435. #define        (kInnerNeutralTreePercentage,          0.18)
  436. #define        (kInnerNeutralLandChaos,        0.9)
  437. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  438. #define        (kInnerNeutralFlatChaos,        0.8)
  439. #define        (kInnerNeutralFlatClumps,        1)
  440.  
  441.  
  442. //////////////////////////////////////////////////////////////////////
  443. // outer neutral definitions
  444. #define        (kNumOuterNeutrals,            14)
  445. #define        (kOuterNeutralPercentLand,        0.65)
  446. #define        (kOuterNeutralPercentFlat,        0.95)
  447. #define        (kOuterNeutralTreePercentage,          0.12)
  448. #define        (kOuterNeutralLandChaos,        0.8)
  449. #define        (kOuterNeutralLandClumps,        1)
  450. #define        (kOuterNeutralFlatChaos,        0.8)
  451. #define        (kOuterNeutralFlatClumps,        1)
  452.  
  453.  
  454. //////////////////////////////////////////////////////////////////////
  455. // resource definitions
  456. #define        (kMaxResourceElevation,            3)
  457. #define        (kResourceToEdgeDistance,        1)
  458. #define        (kResourceToWaterDistance,        1)
  459.  
  460. #define        (kAnimalPerPlayer,            0)
  461. #define        (kAnimalPerNeutral,            0)
  462.  
  463. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  464.   #define  (kBerryPerPlayer,    2) 
  465.   #define  (kBerryPerNeutral,      0)
  466. #else
  467.   #define  (kBerryPerPlayer,    1)
  468.   #define  (kBerryPerNeutral,      0)
  469. #endif 
  470.  
  471. #define        (kFishPerPlayer,                0)
  472. #define        (kFishPerNeutral,                25)
  473.  
  474. #define        (kGoldPerPlayer,                2)
  475. #define        (kGoldPerNeutral,                6)
  476.  
  477. #define        (kOilPerPlayer,                0)
  478. #define        (kOilPerNeutral,                0)
  479.  
  480. #define        (kSteelPerPlayer,                2)
  481. #define        (kSteelPerNeutral,            6)
  482.  
  483. #define        (kStonePerPlayer,                1)
  484. #define        (kStonePerNeutral,            5)
  485.  
  486. #define        (kTreePerPlayer,                1)
  487. #define        (kTreePerNeutral,                0)
  488.  
  489.  
  490. //////////////////////////////////////////////////////////////////////
  491. // forest definitions
  492. #define        (kForestFreeRadius,            7.0)
  493. #define        (kForestsPerPlayer,            1)
  494. #define        (kForestChaosLevel,            .1)
  495. #define        (kMaxClumpsPerForest,              2)
  496.  
  497. #elif Is6Players
  498. //////////////////////////////////////////////////////////////////////
  499. // 6 PLAYERS...
  500. //////////////////////////////////////////////////////////////////////
  501.  
  502. //////////////////////////////////////////////////////////////////////
  503. // terrain definitions
  504. #define        (kMinIntElevation,            -8)
  505.  
  506. #if        PERCENT(80)
  507.   #define        (kMaxIntElevation,            8)
  508. #else
  509.   #define        (kMaxIntElevation,            14)
  510. #endif 
  511.  
  512. #define        (kElevationScale,                0.99)
  513. #define        (kPercentLand,                Between(.7, .7))
  514. #define        (kWaterBorder,                0)
  515. #define        (kHeightMapChaos,                Between(3, 6))
  516.  
  517. #define        (kMinimumStartPositionToMapEdge    2)
  518. #define        (kOuterPushFromMapCenter        30)
  519. #define        (kInnerPushFromMapCenter         30)        
  520.  
  521. #define        (kConvergentSampleSize,            32) 
  522. #define        (kConvergentThreshold,            1)                
  523.  
  524. //////////////////////////////////////////////////////////////////////
  525. // player definitions
  526. #define        (kMaxAngleBetweenTeamMembers,        55.0)
  527. #define        (kPlayerInnerRadius,            0.6)
  528. #define        (kPlayerOuterRadius,            0.99)
  529. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  530. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  531. #define        (kPlayerLandChaos,            0.8)
  532. #define        (kPlayerLandClumps,            1)
  533. #define        (kPlayerFlatChaos,            0.8)
  534. #define        (kPlayerFlatClumps,            1)
  535. #define        (kPlayerTreePercentage,            0.11)
  536.  
  537.  
  538. //////////////////////////////////////////////////////////////////////
  539. // inner neutral definitions
  540. #define        (kNeutralInnerRadius,            0.45)
  541. #define        (kNeutralOuterRadius,            0.45)
  542. #define        (kNeutralOptimalFactor,            0.7)
  543. #define        (kNumInnerNeutrals,            Between(0, 0))
  544. #define        (kInnerNeutralPercentLand,        0.11)
  545. #define        (kInnerNeutralPercentFlat,        0.9)
  546. #define        (kInnerNeutralTreePercentage,          0.18)
  547. #define        (kInnerNeutralLandChaos,        0.9)
  548. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  549. #define        (kInnerNeutralFlatChaos,        0.8)
  550. #define        (kInnerNeutralFlatClumps,        1)
  551.  
  552.  
  553. //////////////////////////////////////////////////////////////////////
  554. // outer neutral definitions
  555. #define        (kNumOuterNeutrals,            13)
  556. #define        (kOuterNeutralPercentLand,        0.54)
  557. #define        (kOuterNeutralPercentFlat,        0.95)
  558. #define        (kOuterNeutralTreePercentage,          0.12)
  559. #define        (kOuterNeutralLandChaos,        0.8)
  560. #define        (kOuterNeutralLandClumps,        1)
  561. #define        (kOuterNeutralFlatChaos,        0.8)
  562. #define        (kOuterNeutralFlatClumps,        1)
  563.  
  564.  
  565. //////////////////////////////////////////////////////////////////////
  566. // resource definitions
  567. #define        (kMaxResourceElevation,            3)
  568. #define        (kResourceToEdgeDistance,        1)
  569. #define        (kResourceToWaterDistance,        1)
  570.  
  571. #define        (kAnimalPerPlayer,            0)
  572. #define        (kAnimalPerNeutral,            0)
  573.  
  574. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  575.   #define  (kBerryPerPlayer,    2) 
  576.   #define  (kBerryPerNeutral,      0)
  577. #else
  578.   #define  (kBerryPerPlayer,    1)
  579.   #define  (kBerryPerNeutral,      0)
  580. #endif 
  581.  
  582. #define        (kFishPerPlayer,                0)
  583. #define        (kFishPerNeutral,                25)
  584.  
  585. #define        (kGoldPerPlayer,                2)
  586. #define        (kGoldPerNeutral,                4)
  587.  
  588. #define        (kOilPerPlayer,                0)
  589. #define        (kOilPerNeutral,                0)
  590.  
  591. #define        (kSteelPerPlayer,                2)
  592. #define        (kSteelPerNeutral,            4)
  593.  
  594. #define        (kStonePerPlayer,                1)
  595. #define        (kStonePerNeutral,            4)
  596.  
  597. #define        (kTreePerPlayer,                1)
  598. #define        (kTreePerNeutral,                0)
  599.  
  600.  
  601. //////////////////////////////////////////////////////////////////////
  602. // forest definitions
  603. #define        (kForestFreeRadius,            6.0)
  604. #define        (kForestsPerPlayer,            1)
  605. #define        (kForestChaosLevel,            .1)
  606. #define        (kMaxClumpsPerForest,              2)
  607.  
  608.  
  609. #elif Is7Players
  610. //////////////////////////////////////////////////////////////////////
  611. // 7 PLAYERS...
  612. //////////////////////////////////////////////////////////////////////
  613.  
  614. //////////////////////////////////////////////////////////////////////
  615. // terrain definitions
  616. #define        (kMinIntElevation,            -8)
  617.  
  618. #if        PERCENT(80)
  619.   #define        (kMaxIntElevation,            8)
  620. #else
  621.   #define        (kMaxIntElevation,            14)
  622. #endif 
  623.  
  624. #define        (kElevationScale,                0.99)
  625. #define        (kPercentLand,                Between(.7, .7))
  626. #define        (kWaterBorder,                0)
  627. #define        (kHeightMapChaos,                Between(3, 6))
  628.  
  629. #define        (kMinimumStartPositionToMapEdge    2)
  630. #define        (kOuterPushFromMapCenter        30)
  631. #define        (kInnerPushFromMapCenter         30)    
  632.  
  633. #define        (kConvergentSampleSize,            32) 
  634. #define        (kConvergentThreshold,            1)
  635.  
  636. //////////////////////////////////////////////////////////////////////
  637. // player definitions
  638. #define        (kMaxAngleBetweenTeamMembers,        66.0)
  639. #define        (kPlayerInnerRadius,            0.6)
  640. #define        (kPlayerOuterRadius,            0.99)
  641. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  642. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  643. #define        (kPlayerLandChaos,            0.8)
  644. #define        (kPlayerLandClumps,            1)
  645. #define        (kPlayerFlatChaos,            0.8)
  646. #define        (kPlayerFlatClumps,            1)
  647. #define        (kPlayerTreePercentage,            0.1)
  648.  
  649.  
  650. //////////////////////////////////////////////////////////////////////
  651. // inner neutral definitions
  652. #define        (kNeutralInnerRadius,            0.45)
  653. #define        (kNeutralOuterRadius,            0.45)
  654. #define        (kNeutralOptimalFactor,            0.7)
  655. #define        (kNumInnerNeutrals,            Between(0, 0))
  656. #define        (kInnerNeutralPercentLand,        0.1)
  657. #define        (kInnerNeutralPercentFlat,        0.9)
  658. #define        (kInnerNeutralTreePercentage,          0.19)
  659. #define        (kInnerNeutralLandChaos,        0.9)
  660. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  661. #define        (kInnerNeutralFlatChaos,        0.8)
  662. #define        (kInnerNeutralFlatClumps,        1)
  663.  
  664. //////////////////////////////////////////////////////////////////////
  665. // outer neutral definitions
  666. #define        (kNumOuterNeutrals,            12)
  667. #define        (kOuterNeutralPercentLand,        0.43)
  668. #define        (kOuterNeutralPercentFlat,        0.95)
  669. #define        (kOuterNeutralTreePercentage,          0.12)
  670. #define        (kOuterNeutralLandChaos,        0.8)
  671. #define        (kOuterNeutralLandClumps,        1)
  672. #define        (kOuterNeutralFlatChaos,        0.8)
  673. #define        (kOuterNeutralFlatClumps,        1)
  674.  
  675. //////////////////////////////////////////////////////////////////////
  676. // resource definitions
  677. #define        (kMaxResourceElevation,            3)
  678. #define        (kResourceToEdgeDistance,        1)
  679. #define        (kResourceToWaterDistance,        1)
  680.  
  681. #define        (kAnimalPerPlayer,            0)
  682. #define        (kAnimalPerNeutral,            0)
  683.  
  684. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  685.   #define  (kBerryPerPlayer,    2) 
  686.   #define  (kBerryPerNeutral,      0)
  687. #else
  688.   #define  (kBerryPerPlayer,    1)
  689.   #define  (kBerryPerNeutral,      0)
  690. #endif 
  691.  
  692. #define        (kFishPerPlayer,                0)
  693. #define        (kFishPerNeutral,                25)
  694.  
  695. #define        (kGoldPerPlayer,                2)
  696. #define        (kGoldPerNeutral,                3)
  697.  
  698. #define        (kOilPerPlayer,                0)
  699. #define        (kOilPerNeutral,                0)
  700.  
  701. #define        (kSteelPerPlayer,                2)
  702. #define        (kSteelPerNeutral,            3)
  703.  
  704. #define        (kStonePerPlayer,                1)
  705. #define        (kStonePerNeutral,            4)
  706.  
  707. #define        (kTreePerPlayer,                1)
  708. #define        (kTreePerNeutral,                0)
  709.  
  710.  
  711. //////////////////////////////////////////////////////////////////////
  712. // forest definitions
  713. #define        (kForestFreeRadius,            6.0)
  714. #define        (kForestsPerPlayer,            1)
  715. #define        (kForestChaosLevel,            .1)
  716. #define        (kMaxClumpsPerForest,              2)
  717.  
  718.  
  719. #elif Is8Players
  720. //////////////////////////////////////////////////////////////////////
  721. // 8 PLAYERS...
  722. //////////////////////////////////////////////////////////////////////
  723.  
  724. //////////////////////////////////////////////////////////////////////
  725. // terrain definitions
  726. #define        (kMinIntElevation,            -8)
  727.  
  728. #if        PERCENT(80)
  729.   #define        (kMaxIntElevation,            8)
  730. #else
  731.   #define        (kMaxIntElevation,            14)
  732. #endif 
  733.  
  734. #define        (kElevationScale,                0.99)
  735. #define        (kPercentLand,                Between(.7, .7))
  736. #define        (kWaterBorder,                0)
  737. #define        (kHeightMapChaos,                Between(3, 6))
  738.  
  739. #define        (kMinimumStartPositionToMapEdge    2)
  740. #define        (kOuterPushFromMapCenter        30)
  741. #define        (kInnerPushFromMapCenter         30)            
  742.  
  743. #define        (kConvergentSampleSize,            32) 
  744. #define        (kConvergentThreshold,            1)                                
  745. //////////////////////////////////////////////////////////////////////
  746. // player definitions
  747. #define        (kMaxAngleBetweenTeamMembers,        66.0)
  748. #define        (kPlayerInnerRadius,            0.7)
  749. #define        (kPlayerOuterRadius,            0.99)
  750. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  751. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  752. #define        (kPlayerLandChaos,            0.8)
  753. #define        (kPlayerLandClumps,            1)
  754. #define        (kPlayerFlatChaos,            0.8)
  755. #define        (kPlayerFlatClumps,            1)
  756. #define        (kPlayerTreePercentage,            0.1)
  757.  
  758.  
  759. //////////////////////////////////////////////////////////////////////
  760. // inner neutral definitions
  761. #define        (kNeutralInnerRadius,            0.45)
  762. #define        (kNeutralOuterRadius,            0.45)
  763. #define        (kNeutralOptimalFactor,            0.7)
  764. #define        (kNumInnerNeutrals,            Between(0, 0))
  765. #define        (kInnerNeutralPercentLand,        0.1)
  766. #define        (kInnerNeutralPercentFlat,        0.9)
  767. #define        (kInnerNeutralTreePercentage,          0.2)
  768. #define        (kInnerNeutralLandChaos,        0.9)
  769. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  770. #define        (kInnerNeutralFlatChaos,        0.8)
  771. #define        (kInnerNeutralFlatClumps,        1)
  772.  
  773.  
  774. //////////////////////////////////////////////////////////////////////
  775. // outer neutral definitions
  776. #define        (kNumOuterNeutrals,            7)
  777. #define        (kOuterNeutralPercentLand,        0.32)
  778. #define        (kOuterNeutralPercentFlat,        0.95)
  779. #define        (kOuterNeutralTreePercentage,          0.12)
  780. #define        (kOuterNeutralLandChaos,        0.8)
  781. #define        (kOuterNeutralLandClumps,        1)
  782. #define        (kOuterNeutralFlatChaos,        0.8)
  783. #define        (kOuterNeutralFlatClumps,        1)
  784.  
  785.  
  786. //////////////////////////////////////////////////////////////////////
  787. // resource definitions
  788. #define        (kMaxResourceElevation,            3)
  789. #define        (kResourceToEdgeDistance,        1)
  790. #define        (kResourceToWaterDistance,        1)
  791.  
  792. #define        (kAnimalPerPlayer,            0)
  793. #define        (kAnimalPerNeutral,            0)
  794.  
  795. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  796.   #define  (kBerryPerPlayer,    2) 
  797.   #define  (kBerryPerNeutral,      0)
  798. #else
  799.   #define  (kBerryPerPlayer,    1)
  800.   #define  (kBerryPerNeutral,      0)
  801. #endif 
  802.  
  803. #define        (kFishPerPlayer,                0)
  804. #define        (kFishPerNeutral,                25)
  805.  
  806. #define        (kGoldPerPlayer,                2)
  807. #define        (kGoldPerNeutral,                0)
  808.  
  809. #define        (kOilPerPlayer,                0)
  810. #define        (kOilPerNeutral,                0)
  811.  
  812. #define        (kSteelPerPlayer,                2)
  813. #define        (kSteelPerNeutral,            0)
  814.  
  815. #define        (kStonePerPlayer,                1)
  816. #define        (kStonePerNeutral,            4)
  817.  
  818. #define        (kTreePerPlayer,                1)
  819. #define        (kTreePerNeutral,                0)
  820.  
  821.  
  822. //////////////////////////////////////////////////////////////////////
  823. // forest definitions
  824. #define        (kForestFreeRadius,            5.0)
  825. #define        (kForestsPerPlayer,            1)
  826. #define        (kForestChaosLevel,            .1)
  827. #define        (kMaxClumpsPerForest,              2)
  828.  
  829.  
  830. #elif Is9Players
  831. //////////////////////////////////////////////////////////////////////
  832. // 9 PLAYERS...
  833. //////////////////////////////////////////////////////////////////////
  834.  
  835. //////////////////////////////////////////////////////////////////////
  836. // terrain definitions
  837. #define        (kMinIntElevation,            -10)
  838. #define        (kMaxIntElevation,            10)
  839. #define        (kElevationScale,                0.99)
  840. #define        (kPercentLand,                Between(.84, .84))
  841. #define        (kWaterBorder,                0)
  842. #define        (kHeightMapChaos,                Between(8, 20))
  843.  
  844. #define        (kMinimumStartPositionToMapEdge    4)
  845. #define        (kOuterPushFromMapCenter        24)
  846. #define        (kInnerPushFromMapCenter         0)    
  847. #define        (kConvergentSampleSize,            32) 
  848. #define        (kConvergentThreshold,            1)                                            
  849. //////////////////////////////////////////////////////////////////////
  850. // player definitions
  851. #define        (kMaxAngleBetweenTeamMembers,        76.0)
  852. #define        (kPlayerInnerRadius,            0.7)
  853. #define        (kPlayerOuterRadius,            0.99)
  854. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  855. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  856. #define        (kPlayerLandChaos,            0.8)
  857. #define        (kPlayerLandClumps,            1)
  858. #define        (kPlayerFlatChaos,            0.8)
  859. #define        (kPlayerFlatClumps,            2)
  860. #define        (kPlayerTreePercentage,            0.1)
  861.  
  862.  
  863. //////////////////////////////////////////////////////////////////////
  864. // inner neutral definitions
  865. #define        (kNeutralInnerRadius,            0.45)
  866. #define        (kNeutralOuterRadius,            0.45)
  867. #define        (kNeutralOptimalFactor,            0.7)
  868. #define        (kNumInnerNeutrals,            Between(3, 3))
  869. #define        (kInnerNeutralPercentLand,        0.1)
  870. #define        (kInnerNeutralPercentFlat,        0.8)
  871. #define        (kInnerNeutralTreePercentage,          0.2)
  872. #define        (kInnerNeutralLandChaos,        0.9)
  873. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  874. #define        (kInnerNeutralFlatChaos,        0.8)
  875. #define        (kInnerNeutralFlatClumps,        1)
  876.  
  877.  
  878. //////////////////////////////////////////////////////////////////////
  879. // outer neutral definitions
  880. #define        (kNumOuterNeutrals,            22)
  881. #define        (kOuterNeutralPercentLand,        0.45)
  882. #define        (kOuterNeutralPercentFlat,        0.8)
  883. #define        (kOuterNeutralTreePercentage,          0.2)
  884. #define        (kOuterNeutralLandChaos,        0.8)
  885. #define        (kOuterNeutralLandClumps,        2)
  886. #define        (kOuterNeutralFlatChaos,        0.8)
  887. #define        (kOuterNeutralFlatClumps,        1)
  888.  
  889.  
  890. //////////////////////////////////////////////////////////////////////
  891. // resource definitions
  892. #define        (kMaxResourceElevation,            3)
  893. #define        (kResourceToEdgeDistance,        3)
  894. #define        (kResourceToWaterDistance,        3)
  895.  
  896. #define        (kAnimalPerPlayer,            0)
  897. #define        (kAnimalPerNeutral,            0)
  898.  
  899. #define        (kBerryPerPlayer,                1)
  900. #define        (kBerryPerNeutral,            0)
  901.  
  902. #define        (kFishPerPlayer,                0)
  903. #define        (kFishPerNeutral,                45)
  904.  
  905. #define        (kGoldPerPlayer,                2)
  906. #define        (kGoldPerNeutral,                0)
  907.  
  908. #define        (kOilPerPlayer,                0)
  909. #define        (kOilPerNeutral,                0)
  910.  
  911. #define        (kSteelPerPlayer,                2)
  912. #define        (kSteelPerNeutral,            0)
  913.  
  914. #define        (kStonePerPlayer,                1)
  915. #define        (kStonePerNeutral,            5)
  916.  
  917. #define        (kTreePerPlayer,                0)
  918. #define        (kTreePerNeutral,                0)
  919.  
  920.  
  921. //////////////////////////////////////////////////////////////////////
  922. // forest definitions
  923. #define        (kForestFreeRadius,            8.0)
  924. #define        (kForestsPerPlayer,            1)
  925. #define        (kForestChaosLevel,            0.9)
  926. #define        (kMaxClumpsPerForest,              2)
  927.  
  928.  
  929. #elif Is10Players
  930. //////////////////////////////////////////////////////////////////////
  931. // 10 PLAYERS...
  932. //////////////////////////////////////////////////////////////////////
  933.  
  934. //////////////////////////////////////////////////////////////////////
  935. // terrain definitions
  936. #define        (kMinIntElevation,            -10)
  937. #define        (kMaxIntElevation,            10)
  938. #define        (kElevationScale,                0.99)
  939. #define        (kPercentLand,                Between(.84, .84))
  940. #define        (kWaterBorder,                0)
  941. #define        (kHeightMapChaos,                Between(8, 20))
  942.  
  943. #define        (kMinimumStartPositionToMapEdge    4)
  944. #define        (kOuterPushFromMapCenter        24)
  945. #define        (kInnerPushFromMapCenter         0)        
  946.  
  947. #define        (kConvergentSampleSize,            32) 
  948. #define        (kConvergentThreshold,            1)                                        
  949. //////////////////////////////////////////////////////////////////////
  950. // player definitions
  951. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  952. #define        (kPlayerInnerRadius,            0.7)
  953. #define        (kPlayerOuterRadius,            0.99)
  954. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  955. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  956. #define        (kPlayerLandChaos,            0.8)
  957. #define        (kPlayerLandClumps,            1)
  958. #define        (kPlayerFlatChaos,            0.8)
  959. #define        (kPlayerFlatClumps,            2)
  960. #define        (kPlayerTreePercentage,            0.1)
  961.  
  962.  
  963. //////////////////////////////////////////////////////////////////////
  964. // inner neutral definitions
  965. #define        (kNeutralInnerRadius,            0.45)
  966. #define        (kNeutralOuterRadius,            0.45)
  967. #define        (kNeutralOptimalFactor,            0.7)
  968. #define        (kNumInnerNeutrals,            Between(3, 3))
  969. #define        (kInnerNeutralPercentLand,        0.1)
  970. #define        (kInnerNeutralPercentFlat,        0.8)
  971. #define        (kInnerNeutralTreePercentage,          0.2)
  972. #define        (kInnerNeutralLandChaos,        0.9)
  973. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  974. #define        (kInnerNeutralFlatChaos,        0.8)
  975. #define        (kInnerNeutralFlatClumps,        1)
  976.  
  977.  
  978. //////////////////////////////////////////////////////////////////////
  979. // outer neutral definitions
  980. #define        (kNumOuterNeutrals,            22)
  981. #define        (kOuterNeutralPercentLand,        0.45)
  982. #define        (kOuterNeutralPercentFlat,        0.8)
  983. #define        (kOuterNeutralTreePercentage,          0.2)
  984. #define        (kOuterNeutralLandChaos,        0.8)
  985. #define        (kOuterNeutralLandClumps,        2)
  986. #define        (kOuterNeutralFlatChaos,        0.8)
  987. #define        (kOuterNeutralFlatClumps,        1)
  988.  
  989.  
  990. //////////////////////////////////////////////////////////////////////
  991. // resource definitions
  992. #define        (kMaxResourceElevation,            3)
  993. #define        (kResourceToEdgeDistance,        3)
  994. #define        (kResourceToWaterDistance,        3)
  995.  
  996. #define        (kAnimalPerPlayer,            0)
  997. #define        (kAnimalPerNeutral,            0)
  998.  
  999. #define        (kBerryPerPlayer,                1)
  1000. #define        (kBerryPerNeutral,            0)
  1001.  
  1002. #define        (kFishPerPlayer,                0)
  1003. #define        (kFishPerNeutral,                45)
  1004.  
  1005. #define        (kGoldPerPlayer,                2)
  1006. #define        (kGoldPerNeutral,                0)
  1007.  
  1008. #define        (kOilPerPlayer,                0)
  1009. #define        (kOilPerNeutral,                0)
  1010.  
  1011. #define        (kSteelPerPlayer,                2)
  1012. #define        (kSteelPerNeutral,            0)
  1013.  
  1014. #define        (kStonePerPlayer,                1)
  1015. #define        (kStonePerNeutral,            5)
  1016.  
  1017. #define        (kTreePerPlayer,                0)
  1018. #define        (kTreePerNeutral,                0)
  1019.  
  1020.  
  1021. //////////////////////////////////////////////////////////////////////
  1022. // forest definitions
  1023. #define        (kForestFreeRadius,            8.0)
  1024. #define        (kForestsPerPlayer,            1)
  1025. #define        (kForestChaosLevel,            0.9)
  1026. #define        (kMaxClumpsPerForest,              2)
  1027.  
  1028.  
  1029. #elif Is11Players
  1030. //////////////////////////////////////////////////////////////////////
  1031. // 11 PLAYERS...
  1032. //////////////////////////////////////////////////////////////////////
  1033.  
  1034. //////////////////////////////////////////////////////////////////////
  1035. // terrain definitions
  1036. #define        (kMinIntElevation,            -10)
  1037. #define        (kMaxIntElevation,            10)
  1038. #define        (kElevationScale,                0.99)
  1039. #define        (kPercentLand,                Between(.84, .84))
  1040. #define        (kWaterBorder,                0)
  1041. #define        (kHeightMapChaos,                Between(8, 20))
  1042.  
  1043. #define        (kMinimumStartPositionToMapEdge    4)
  1044. #define        (kOuterPushFromMapCenter        24)
  1045. #define        (kInnerPushFromMapCenter         0)                                            
  1046. //////////////////////////////////////////////////////////////////////
  1047. // player definitions
  1048. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1049. #define        (kPlayerInnerRadius,            0.7)
  1050. #define        (kPlayerOuterRadius,            0.99)
  1051. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1052. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1053. #define        (kPlayerLandChaos,            0.8)
  1054. #define        (kPlayerLandClumps,            1)
  1055. #define        (kPlayerFlatChaos,            0.8)
  1056. #define        (kPlayerFlatClumps,            2)
  1057. #define        (kPlayerTreePercentage,            0.1)
  1058.  
  1059.  
  1060. //////////////////////////////////////////////////////////////////////
  1061. // inner neutral definitions
  1062. #define        (kNeutralInnerRadius,            0.45)
  1063. #define        (kNeutralOuterRadius,            0.45)
  1064. #define        (kNeutralOptimalFactor,            0.7)
  1065. #define        (kNumInnerNeutrals,            Between(3, 3))
  1066. #define        (kInnerNeutralPercentLand,        0.1)
  1067. #define        (kInnerNeutralPercentFlat,        0.8)
  1068. #define        (kInnerNeutralTreePercentage,          0.2)
  1069. #define        (kInnerNeutralLandChaos,        0.9)
  1070. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1071. #define        (kInnerNeutralFlatChaos,        0.8)
  1072. #define        (kInnerNeutralFlatClumps,        1)
  1073.  
  1074.  
  1075. //////////////////////////////////////////////////////////////////////
  1076. // outer neutral definitions
  1077. #define        (kNumOuterNeutrals,            22)
  1078. #define        (kOuterNeutralPercentLand,        0.45)
  1079. #define        (kOuterNeutralPercentFlat,        0.8)
  1080. #define        (kOuterNeutralTreePercentage,          0.2)
  1081. #define        (kOuterNeutralLandChaos,        0.8)
  1082. #define        (kOuterNeutralLandClumps,        2)
  1083. #define        (kOuterNeutralFlatChaos,        0.8)
  1084. #define        (kOuterNeutralFlatClumps,        1)
  1085.  
  1086.  
  1087. //////////////////////////////////////////////////////////////////////
  1088. // resource definitions
  1089. #define        (kMaxResourceElevation,            3)
  1090. #define        (kResourceToEdgeDistance,        3)
  1091. #define        (kResourceToWaterDistance,        3)
  1092.  
  1093. #define        (kAnimalPerPlayer,            0)
  1094. #define        (kAnimalPerNeutral,            0)
  1095.  
  1096. #define        (kBerryPerPlayer,                1)
  1097. #define        (kBerryPerNeutral,            0)
  1098.  
  1099. #define        (kFishPerPlayer,                0)
  1100. #define        (kFishPerNeutral,                45)
  1101.  
  1102. #define        (kGoldPerPlayer,                2)
  1103. #define        (kGoldPerNeutral,                0)
  1104.  
  1105. #define        (kOilPerPlayer,                0)
  1106. #define        (kOilPerNeutral,                0)
  1107.  
  1108. #define        (kSteelPerPlayer,                2)
  1109. #define        (kSteelPerNeutral,            0)
  1110.  
  1111. #define        (kStonePerPlayer,                1)
  1112. #define        (kStonePerNeutral,            5)
  1113.  
  1114. #define        (kTreePerPlayer,                0)
  1115. #define        (kTreePerNeutral,                0)
  1116.  
  1117.  
  1118. //////////////////////////////////////////////////////////////////////
  1119. // forest definitions
  1120. #define        (kForestFreeRadius,            8.0)
  1121. #define        (kForestsPerPlayer,            1)
  1122. #define        (kForestChaosLevel,            0.9)
  1123. #define        (kMaxClumpsPerForest,              2)
  1124.  
  1125.  
  1126. #elif Is12Players
  1127. //////////////////////////////////////////////////////////////////////
  1128. // 12 PLAYERS...
  1129. //////////////////////////////////////////////////////////////////////
  1130.  
  1131. //////////////////////////////////////////////////////////////////////
  1132. // terrain definitions
  1133. #define        (kMinIntElevation,            -10)
  1134. #define        (kMaxIntElevation,            10)
  1135. #define        (kElevationScale,                0.99)
  1136. #define        (kPercentLand,                Between(.84, .84))
  1137. #define        (kWaterBorder,                0)
  1138. #define        (kHeightMapChaos,                Between(8, 20))
  1139.  
  1140. #define        (kMinimumStartPositionToMapEdge    4)
  1141. #define        (kOuterPushFromMapCenter        24)
  1142. #define        (kInnerPushFromMapCenter         0)                                            
  1143. //////////////////////////////////////////////////////////////////////
  1144. // player definitions
  1145. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1146. #define        (kPlayerInnerRadius,            0.7)
  1147. #define        (kPlayerOuterRadius,            0.99)
  1148. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1149. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1150. #define        (kPlayerLandChaos,            0.8)
  1151. #define        (kPlayerLandClumps,            1)
  1152. #define        (kPlayerFlatChaos,            0.8)
  1153. #define        (kPlayerFlatClumps,            2)
  1154. #define        (kPlayerTreePercentage,            0.1)
  1155.  
  1156.  
  1157. //////////////////////////////////////////////////////////////////////
  1158. // inner neutral definitions
  1159. #define        (kNeutralInnerRadius,            0.45)
  1160. #define        (kNeutralOuterRadius,            0.45)
  1161. #define        (kNeutralOptimalFactor,            0.7)
  1162. #define        (kNumInnerNeutrals,            Between(3, 3))
  1163. #define        (kInnerNeutralPercentLand,        0.1)
  1164. #define        (kInnerNeutralPercentFlat,        0.8)
  1165. #define        (kInnerNeutralTreePercentage,          0.2)
  1166. #define        (kInnerNeutralLandChaos,        0.9)
  1167. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1168. #define        (kInnerNeutralFlatChaos,        0.8)
  1169. #define        (kInnerNeutralFlatClumps,        1)
  1170.  
  1171.  
  1172. //////////////////////////////////////////////////////////////////////
  1173. // outer neutral definitions
  1174. #define        (kNumOuterNeutrals,            22)
  1175. #define        (kOuterNeutralPercentLand,        0.45)
  1176. #define        (kOuterNeutralPercentFlat,        0.8)
  1177. #define        (kOuterNeutralTreePercentage,          0.2)
  1178. #define        (kOuterNeutralLandChaos,        0.8)
  1179. #define        (kOuterNeutralLandClumps,        2)
  1180. #define        (kOuterNeutralFlatChaos,        0.8)
  1181. #define        (kOuterNeutralFlatClumps,        1)
  1182.  
  1183.  
  1184. //////////////////////////////////////////////////////////////////////
  1185. // resource definitions
  1186. #define        (kMaxResourceElevation,            3)
  1187. #define        (kResourceToEdgeDistance,        3)
  1188. #define        (kResourceToWaterDistance,        3)
  1189.  
  1190. #define        (kAnimalPerPlayer,            0)
  1191. #define        (kAnimalPerNeutral,            0)
  1192.  
  1193. #define        (kBerryPerPlayer,                1)
  1194. #define        (kBerryPerNeutral,            0)
  1195.  
  1196. #define        (kFishPerPlayer,                0)
  1197. #define        (kFishPerNeutral,                45)
  1198.  
  1199. #define        (kGoldPerPlayer,                2)
  1200. #define        (kGoldPerNeutral,                0)
  1201.  
  1202. #define        (kOilPerPlayer,                0)
  1203. #define        (kOilPerNeutral,                0)
  1204.  
  1205. #define        (kSteelPerPlayer,                2)
  1206. #define        (kSteelPerNeutral,            0)
  1207.  
  1208. #define        (kStonePerPlayer,                1)
  1209. #define        (kStonePerNeutral,            5)
  1210.  
  1211. #define        (kTreePerPlayer,                0)
  1212. #define        (kTreePerNeutral,                0)
  1213.  
  1214.  
  1215. //////////////////////////////////////////////////////////////////////
  1216. // forest definitions
  1217. #define        (kForestFreeRadius,            8.0)
  1218. #define        (kForestsPerPlayer,            1)
  1219. #define        (kForestChaosLevel,            0.9)
  1220. #define        (kMaxClumpsPerForest,              2)
  1221.  
  1222.  
  1223. #elif Is13Players
  1224. //////////////////////////////////////////////////////////////////////
  1225. // 13 PLAYERS...
  1226. //////////////////////////////////////////////////////////////////////
  1227.  
  1228. //////////////////////////////////////////////////////////////////////
  1229. // terrain definitions
  1230. #define        (kMinIntElevation,            -10)
  1231. #define        (kMaxIntElevation,            10)
  1232. #define        (kElevationScale,                0.99)
  1233. #define        (kPercentLand,                Between(.84, .84))
  1234. #define        (kWaterBorder,                0)
  1235. #define        (kHeightMapChaos,                Between(8, 20))
  1236.  
  1237. #define        (kMinimumStartPositionToMapEdge    4)
  1238. #define        (kOuterPushFromMapCenter        24)
  1239. #define        (kInnerPushFromMapCenter         0)                                            
  1240. //////////////////////////////////////////////////////////////////////
  1241. // player definitions
  1242. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1243. #define        (kPlayerInnerRadius,            0.7)
  1244. #define        (kPlayerOuterRadius,            0.99)
  1245. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1246. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1247. #define        (kPlayerLandChaos,            0.8)
  1248. #define        (kPlayerLandClumps,            1)
  1249. #define        (kPlayerFlatChaos,            0.8)
  1250. #define        (kPlayerFlatClumps,            2)
  1251. #define        (kPlayerTreePercentage,            0.1)
  1252.  
  1253.  
  1254. //////////////////////////////////////////////////////////////////////
  1255. // inner neutral definitions
  1256. #define        (kNeutralInnerRadius,            0.45)
  1257. #define        (kNeutralOuterRadius,            0.45)
  1258. #define        (kNeutralOptimalFactor,            0.7)
  1259. #define        (kNumInnerNeutrals,            Between(3, 3))
  1260. #define        (kInnerNeutralPercentLand,        0.1)
  1261. #define        (kInnerNeutralPercentFlat,        0.8)
  1262. #define        (kInnerNeutralTreePercentage,          0.2)
  1263. #define        (kInnerNeutralLandChaos,        0.9)
  1264. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1265. #define        (kInnerNeutralFlatChaos,        0.8)
  1266. #define        (kInnerNeutralFlatClumps,        1)
  1267.  
  1268.  
  1269. //////////////////////////////////////////////////////////////////////
  1270. // outer neutral definitions
  1271. #define        (kNumOuterNeutrals,            22)
  1272. #define        (kOuterNeutralPercentLand,        0.45)
  1273. #define        (kOuterNeutralPercentFlat,        0.8)
  1274. #define        (kOuterNeutralTreePercentage,          0.2)
  1275. #define        (kOuterNeutralLandChaos,        0.8)
  1276. #define        (kOuterNeutralLandClumps,        2)
  1277. #define        (kOuterNeutralFlatChaos,        0.8)
  1278. #define        (kOuterNeutralFlatClumps,        1)
  1279.  
  1280.  
  1281. //////////////////////////////////////////////////////////////////////
  1282. // resource definitions
  1283. #define        (kMaxResourceElevation,            3)
  1284. #define        (kResourceToEdgeDistance,        3)
  1285. #define        (kResourceToWaterDistance,        3)
  1286.  
  1287. #define        (kAnimalPerPlayer,            0)
  1288. #define        (kAnimalPerNeutral,            0)
  1289.  
  1290. #define        (kBerryPerPlayer,                1)
  1291. #define        (kBerryPerNeutral,            0)
  1292.  
  1293. #define        (kFishPerPlayer,                0)
  1294. #define        (kFishPerNeutral,                45)
  1295.  
  1296. #define        (kGoldPerPlayer,                2)
  1297. #define        (kGoldPerNeutral,                0)
  1298.  
  1299. #define        (kOilPerPlayer,                0)
  1300. #define        (kOilPerNeutral,                0)
  1301.  
  1302. #define        (kSteelPerPlayer,                2)
  1303. #define        (kSteelPerNeutral,            0)
  1304.  
  1305. #define        (kStonePerPlayer,                1)
  1306. #define        (kStonePerNeutral,            5)
  1307.  
  1308. #define        (kTreePerPlayer,                0)
  1309. #define        (kTreePerNeutral,                0)
  1310.  
  1311.  
  1312. //////////////////////////////////////////////////////////////////////
  1313. // forest definitions
  1314. #define        (kForestFreeRadius,            8.0)
  1315. #define        (kForestsPerPlayer,            1)
  1316. #define        (kForestChaosLevel,            0.9)
  1317. #define        (kMaxClumpsPerForest,              2)
  1318.  
  1319.  
  1320. #elif Is14Players
  1321. //////////////////////////////////////////////////////////////////////
  1322. // 14 PLAYERS...
  1323. //////////////////////////////////////////////////////////////////////
  1324.  
  1325. //////////////////////////////////////////////////////////////////////
  1326. // terrain definitions
  1327. #define        (kMinIntElevation,            -10)
  1328. #define        (kMaxIntElevation,            10)
  1329. #define        (kElevationScale,                0.99)
  1330. #define        (kPercentLand,                Between(.84, .84))
  1331. #define        (kWaterBorder,                0)
  1332. #define        (kHeightMapChaos,                Between(8, 20))
  1333.  
  1334. #define        (kMinimumStartPositionToMapEdge    4)
  1335. #define        (kOuterPushFromMapCenter        24)
  1336. #define        (kInnerPushFromMapCenter         0)                                            
  1337. //////////////////////////////////////////////////////////////////////
  1338. // player definitions
  1339. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1340. #define        (kPlayerInnerRadius,            0.7)
  1341. #define        (kPlayerOuterRadius,            0.99)
  1342. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1343. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1344. #define        (kPlayerLandChaos,            0.8)
  1345. #define        (kPlayerLandClumps,            1)
  1346. #define        (kPlayerFlatChaos,            0.8)
  1347. #define        (kPlayerFlatClumps,            2)
  1348. #define        (kPlayerTreePercentage,            0.1)
  1349.  
  1350.  
  1351. //////////////////////////////////////////////////////////////////////
  1352. // inner neutral definitions
  1353. #define        (kNeutralInnerRadius,            0.45)
  1354. #define        (kNeutralOuterRadius,            0.45)
  1355. #define        (kNeutralOptimalFactor,            0.7)
  1356. #define        (kNumInnerNeutrals,            Between(3, 3))
  1357. #define        (kInnerNeutralPercentLand,        0.1)
  1358. #define        (kInnerNeutralPercentFlat,        0.8)
  1359. #define        (kInnerNeutralTreePercentage,          0.2)
  1360. #define        (kInnerNeutralLandChaos,        0.9)
  1361. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1362. #define        (kInnerNeutralFlatChaos,        0.8)
  1363. #define        (kInnerNeutralFlatClumps,        1)
  1364.  
  1365.  
  1366. //////////////////////////////////////////////////////////////////////
  1367. // outer neutral definitions
  1368. #define        (kNumOuterNeutrals,            22)
  1369. #define        (kOuterNeutralPercentLand,        0.45)
  1370. #define        (kOuterNeutralPercentFlat,        0.8)
  1371. #define        (kOuterNeutralTreePercentage,          0.2)
  1372. #define        (kOuterNeutralLandChaos,        0.8)
  1373. #define        (kOuterNeutralLandClumps,        2)
  1374. #define        (kOuterNeutralFlatChaos,        0.8)
  1375. #define        (kOuterNeutralFlatClumps,        1)
  1376.  
  1377.  
  1378. //////////////////////////////////////////////////////////////////////
  1379. // resource definitions
  1380. #define        (kMaxResourceElevation,            3)
  1381. #define        (kResourceToEdgeDistance,        3)
  1382. #define        (kResourceToWaterDistance,        3)
  1383.  
  1384. #define        (kAnimalPerPlayer,            0)
  1385. #define        (kAnimalPerNeutral,            0)
  1386.  
  1387. #define        (kBerryPerPlayer,                1)
  1388. #define        (kBerryPerNeutral,            0)
  1389.  
  1390. #define        (kFishPerPlayer,                0)
  1391. #define        (kFishPerNeutral,                45)
  1392.  
  1393. #define        (kGoldPerPlayer,                2)
  1394. #define        (kGoldPerNeutral,                0)
  1395.  
  1396. #define        (kOilPerPlayer,                0)
  1397. #define        (kOilPerNeutral,                0)
  1398.  
  1399. #define        (kSteelPerPlayer,                2)
  1400. #define        (kSteelPerNeutral,            0)
  1401.  
  1402. #define        (kStonePerPlayer,                1)
  1403. #define        (kStonePerNeutral,            5)
  1404.  
  1405. #define        (kTreePerPlayer,                0)
  1406. #define        (kTreePerNeutral,                0)
  1407.  
  1408.  
  1409. //////////////////////////////////////////////////////////////////////
  1410. // forest definitions
  1411. #define        (kForestFreeRadius,            8.0)
  1412. #define        (kForestsPerPlayer,            1)
  1413. #define        (kForestChaosLevel,            0.9)
  1414. #define        (kMaxClumpsPerForest,              2)
  1415.  
  1416.  
  1417. #elif Is15Players
  1418. //////////////////////////////////////////////////////////////////////
  1419. // 15 PLAYERS...
  1420. //////////////////////////////////////////////////////////////////////
  1421.  
  1422. //////////////////////////////////////////////////////////////////////
  1423. // terrain definitions
  1424. #define        (kMinIntElevation,            -10)
  1425. #define        (kMaxIntElevation,            10)
  1426. #define        (kElevationScale,                0.99)
  1427. #define        (kPercentLand,                Between(.84, .84))
  1428. #define        (kWaterBorder,                0)
  1429. #define        (kHeightMapChaos,                Between(8, 20))
  1430.  
  1431. #define        (kMinimumStartPositionToMapEdge    4)
  1432. #define        (kOuterPushFromMapCenter        24)
  1433. #define        (kInnerPushFromMapCenter         0)                                            
  1434. //////////////////////////////////////////////////////////////////////
  1435. // player definitions
  1436. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1437. #define        (kPlayerInnerRadius,            0.7)
  1438. #define        (kPlayerOuterRadius,            0.99)
  1439. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1440. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1441. #define        (kPlayerLandChaos,            0.8)
  1442. #define        (kPlayerLandClumps,            1)
  1443. #define        (kPlayerFlatChaos,            0.8)
  1444. #define        (kPlayerFlatClumps,            2)
  1445. #define        (kPlayerTreePercentage,            0.1)
  1446.  
  1447.  
  1448. //////////////////////////////////////////////////////////////////////
  1449. // inner neutral definitions
  1450. #define        (kNeutralInnerRadius,            0.45)
  1451. #define        (kNeutralOuterRadius,            0.45)
  1452. #define        (kNeutralOptimalFactor,            0.7)
  1453. #define        (kNumInnerNeutrals,            Between(3, 3))
  1454. #define        (kInnerNeutralPercentLand,        0.1)
  1455. #define        (kInnerNeutralPercentFlat,        0.8)
  1456. #define        (kInnerNeutralTreePercentage,          0.2)
  1457. #define        (kInnerNeutralLandChaos,        0.9)
  1458. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1459. #define        (kInnerNeutralFlatChaos,        0.8)
  1460. #define        (kInnerNeutralFlatClumps,        1)
  1461.  
  1462.  
  1463. //////////////////////////////////////////////////////////////////////
  1464. // outer neutral definitions
  1465. #define        (kNumOuterNeutrals,            22)
  1466. #define        (kOuterNeutralPercentLand,        0.45)
  1467. #define        (kOuterNeutralPercentFlat,        0.8)
  1468. #define        (kOuterNeutralTreePercentage,          0.2)
  1469. #define        (kOuterNeutralLandChaos,        0.8)
  1470. #define        (kOuterNeutralLandClumps,        2)
  1471. #define        (kOuterNeutralFlatChaos,        0.8)
  1472. #define        (kOuterNeutralFlatClumps,        1)
  1473.  
  1474.  
  1475. //////////////////////////////////////////////////////////////////////
  1476. // resource definitions
  1477. #define        (kMaxResourceElevation,            3)
  1478. #define        (kResourceToEdgeDistance,        3)
  1479. #define        (kResourceToWaterDistance,        3)
  1480.  
  1481. #define        (kAnimalPerPlayer,            0)
  1482. #define        (kAnimalPerNeutral,            0)
  1483.  
  1484. #define        (kBerryPerPlayer,                1)
  1485. #define        (kBerryPerNeutral,            0)
  1486.  
  1487. #define        (kFishPerPlayer,                0)
  1488. #define        (kFishPerNeutral,                45)
  1489.  
  1490. #define        (kGoldPerPlayer,                2)
  1491. #define        (kGoldPerNeutral,                0)
  1492.  
  1493. #define        (kOilPerPlayer,                0)
  1494. #define        (kOilPerNeutral,                0)
  1495.  
  1496. #define        (kSteelPerPlayer,                2)
  1497. #define        (kSteelPerNeutral,            0)
  1498.  
  1499. #define        (kStonePerPlayer,                1)
  1500. #define        (kStonePerNeutral,            5)
  1501.  
  1502. #define        (kTreePerPlayer,                0)
  1503. #define        (kTreePerNeutral,                0)
  1504.  
  1505.  
  1506. //////////////////////////////////////////////////////////////////////
  1507. // forest definitions
  1508. #define        (kForestFreeRadius,            8.0)
  1509. #define        (kForestsPerPlayer,            1)
  1510. #define        (kForestChaosLevel,            0.9)
  1511. #define        (kMaxClumpsPerForest,              2)
  1512.  
  1513.  
  1514. #elif Is16Players
  1515. //////////////////////////////////////////////////////////////////////
  1516. // 16 PLAYERS...
  1517. //////////////////////////////////////////////////////////////////////
  1518.  
  1519. //////////////////////////////////////////////////////////////////////
  1520. // terrain definitions
  1521. #define        (kMinIntElevation,            -10)
  1522. #define        (kMaxIntElevation,            10)
  1523. #define        (kElevationScale,                0.99)
  1524. #define        (kPercentLand,                Between(.84, .84))
  1525. #define        (kWaterBorder,                0)
  1526. #define        (kHeightMapChaos,                Between(8, 20))
  1527.  
  1528. #define        (kMinimumStartPositionToMapEdge    4)
  1529. #define        (kOuterPushFromMapCenter        24)
  1530. #define        (kInnerPushFromMapCenter         0)                                            
  1531. //////////////////////////////////////////////////////////////////////
  1532. // player definitions
  1533. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1534. #define        (kPlayerInnerRadius,            0.7)
  1535. #define        (kPlayerOuterRadius,            0.99)
  1536. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1537. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  1538. #define        (kPlayerLandChaos,            0.8)
  1539. #define        (kPlayerLandClumps,            1)
  1540. #define        (kPlayerFlatChaos,            0.8)
  1541. #define        (kPlayerFlatClumps,            2)
  1542. #define        (kPlayerTreePercentage,            0.1)
  1543.  
  1544.  
  1545. //////////////////////////////////////////////////////////////////////
  1546. // inner neutral definitions
  1547. #define        (kNeutralInnerRadius,            0.45)
  1548. #define        (kNeutralOuterRadius,            0.45)
  1549. #define        (kNeutralOptimalFactor,            0.7)
  1550. #define        (kNumInnerNeutrals,            Between(3, 3))
  1551. #define        (kInnerNeutralPercentLand,        0.1)
  1552. #define        (kInnerNeutralPercentFlat,        0.8)
  1553. #define        (kInnerNeutralTreePercentage,          0.2)
  1554. #define        (kInnerNeutralLandChaos,        0.9)
  1555. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1556. #define        (kInnerNeutralFlatChaos,        0.8)
  1557. #define        (kInnerNeutralFlatClumps,        1)
  1558.  
  1559.  
  1560. //////////////////////////////////////////////////////////////////////
  1561. // outer neutral definitions
  1562. #define        (kNumOuterNeutrals,            22)
  1563. #define        (kOuterNeutralPercentLand,        0.45)
  1564. #define        (kOuterNeutralPercentFlat,        0.8)
  1565. #define        (kOuterNeutralTreePercentage,          0.2)
  1566. #define        (kOuterNeutralLandChaos,        0.8)
  1567. #define        (kOuterNeutralLandClumps,        2)
  1568. #define        (kOuterNeutralFlatChaos,        0.8)
  1569. #define        (kOuterNeutralFlatClumps,        1)
  1570.  
  1571.  
  1572. //////////////////////////////////////////////////////////////////////
  1573. // resource definitions
  1574. #define        (kMaxResourceElevation,            3)
  1575. #define        (kResourceToEdgeDistance,        3)
  1576. #define        (kResourceToWaterDistance,        3)
  1577.  
  1578. #define        (kAnimalPerPlayer,            0)
  1579. #define        (kAnimalPerNeutral,            0)
  1580.  
  1581. #define        (kBerryPerPlayer,                1)
  1582. #define        (kBerryPerNeutral,            0)
  1583.  
  1584. #define        (kFishPerPlayer,                0)
  1585. #define        (kFishPerNeutral,                45)
  1586.  
  1587. #define        (kGoldPerPlayer,                2)
  1588. #define        (kGoldPerNeutral,                0)
  1589.  
  1590. #define        (kOilPerPlayer,                0)
  1591. #define        (kOilPerNeutral,                0)
  1592.  
  1593. #define        (kSteelPerPlayer,                2)
  1594. #define        (kSteelPerNeutral,            0)
  1595.  
  1596. #define        (kStonePerPlayer,                1)
  1597. #define        (kStonePerNeutral,            5)
  1598.  
  1599. #define        (kTreePerPlayer,                0)
  1600. #define        (kTreePerNeutral,                0)
  1601.  
  1602.  
  1603. //////////////////////////////////////////////////////////////////////
  1604. // forest definitions
  1605. #define        (kForestFreeRadius,            8.0)
  1606. #define        (kForestsPerPlayer,            1)
  1607. #define        (kForestChaosLevel,            0.9)
  1608. #define        (kMaxClumpsPerForest,              2)
  1609.  
  1610.  
  1611. //////////////////////////////////////////////////////////////////////
  1612. // End of if...elif... command
  1613. #endif
  1614.  
  1615.  
  1616. #endif        // NOTDEFINED(MEDITERRANEAN_SMALL_RMV)
  1617.